/**
 * 全局同步任务管理器
 * 提供全局的同步任务监控和进度管理功能
 * 类似于数据血缘的全局进度管理器
 */

import { SyncTaskProgressHook } from '../hooks/useSyncTaskProgress';
import { syncTaskMonitor } from '../services/syncTaskMonitor';

class GlobalSyncTaskManager {
  private syncProgressHook: SyncTaskProgressHook | null = null;
  private isInitialized = false;

  /**
   * 初始化全局同步任务管理器（只在应用启动时调用一次）
   * @param hooks useSyncTaskProgress Hook实例
   */
  initialize(hooks: SyncTaskProgressHook) {
    if (!this.isInitialized) {
      this.syncProgressHook = hooks;
      this.isInitialized = true;

      // 初始化监控服务
      syncTaskMonitor.initialize(hooks);

      console.log('🔧 GlobalSyncTaskManager 已初始化');
    }
  }

  /**
   * 更新Hook引用（用于React组件重新渲染时）
   * @param hooks 新的Hook实例
   */
  updateHooks(hooks: SyncTaskProgressHook) {
    if (this.isInitialized) {
      this.syncProgressHook = hooks;
      // 也更新监控服务的hook引用
      syncTaskMonitor.updateHooks(hooks);
    }
  }

  /**
   * 启动同步任务进度监控（返回通知ID）
   * @param taskName 任务名称
   * @param sourceType 源数据类型
   * @param targetType 目标数据类型
   * @returns 通知ID
   */
  startSyncTask(taskName: string, sourceType: string, targetType: string): string | null {
    if (!this.syncProgressHook) {
      console.warn('⚠️ GlobalSyncTaskManager 未初始化');
      return null;
    }
    
    try {
      const notificationId = this.syncProgressHook.startSyncTask(taskName, sourceType, targetType);
      console.log(`📊 启动同步任务进度跟踪: ${notificationId}`);
      return notificationId;
    } catch (error) {
      console.error('❌ 启动同步任务失败:', error);
      return null;
    }
  }

  /**
   * 更新同步任务进度（不触发组件重新渲染）
   * @param notificationId 通知ID
   * @param progress 进度百分比
   * @param currentStage 当前阶段
   * @param processedRecords 已处理记录数
   * @param totalRecords 总记录数
   * @param statistics 统计信息
   */
  updateSyncProgress(
    notificationId: string,
    progress: number,
    currentStage: string,
    processedRecords: number = 0,
    totalRecords: number = 0,
    statistics?: Record<string, any>
  ) {
    if (!this.syncProgressHook || !notificationId) return;
    
    try {
      this.syncProgressHook.updateSyncProgress(
        notificationId,
        progress,
        currentStage,
        processedRecords,
        totalRecords,
        statistics
      );
    } catch (error) {
      console.error('❌ 更新同步进度失败:', error);
    }
  }

  /**
   * 完成同步任务
   * @param notificationId 通知ID
   * @param success 是否成功
   * @param summary 完成摘要
   * @param statistics 最终统计信息
   */
  completeSyncTask(
    notificationId: string,
    success: boolean,
    summary?: string,
    statistics?: Record<string, any>
  ) {
    if (!this.syncProgressHook || !notificationId) return;
    
    try {
      this.syncProgressHook.completeSyncTask(notificationId, success, summary, statistics);
      console.log(`✅ 同步任务完成: ${notificationId}`);
    } catch (error) {
      console.error('❌ 完成同步任务失败:', error);
    }
  }

  /**
   * 暂停同步任务
   * @param notificationId 通知ID
   */
  pauseSyncTask(notificationId: string) {
    if (!this.syncProgressHook || !notificationId) return;
    
    try {
      this.syncProgressHook.pauseSyncTask(notificationId);
      console.log(`⏸️ 同步任务已暂停: ${notificationId}`);
    } catch (error) {
      console.error('❌ 暂停同步任务失败:', error);
    }
  }

  /**
   * 恢复同步任务
   * @param notificationId 通知ID
   */
  resumeSyncTask(notificationId: string) {
    if (!this.syncProgressHook || !notificationId) return;
    
    try {
      this.syncProgressHook.resumeSyncTask(notificationId);
      console.log(`▶️ 同步任务已恢复: ${notificationId}`);
    } catch (error) {
      console.error('❌ 恢复同步任务失败:', error);
    }
  }

  /**
   * 取消同步任务
   * @param notificationId 通知ID
   * @param reason 取消原因
   */
  cancelSyncTask(notificationId: string, reason?: string) {
    if (!this.syncProgressHook || !notificationId) return;
    
    try {
      this.syncProgressHook.cancelSyncTask(notificationId, reason);
      console.log(`❌ 同步任务已取消: ${notificationId}`);
    } catch (error) {
      console.error('❌ 取消同步任务失败:', error);
    }
  }

  /**
   * 同步任务失败
   * @param notificationId 通知ID
   * @param error 错误信息
   */
  failSyncTask(notificationId: string, error: { message: string; code?: string; details?: any }) {
    if (!this.syncProgressHook || !notificationId) return;
    
    try {
      this.syncProgressHook.failSyncTask(notificationId, error);
      console.log(`💥 同步任务失败: ${notificationId}`);
    } catch (err) {
      console.error('❌ 标记同步任务失败时出错:', err);
    }
  }

  /**
   * 使用监控服务启动任务监控
   * @param executionId 执行记录ID
   * @param taskName 任务名称
   * @param sourceType 源数据类型
   * @param targetType 目标数据类型
   * @returns 通知ID
   */
  startTaskMonitoring(
    executionId: number,
    taskName: string,
    sourceType: string,
    targetType: string
  ): string | null {
    return syncTaskMonitor.startMonitoring(executionId, taskName, sourceType, targetType);
  }

  /**
   * 停止任务监控
   * @param executionId 执行记录ID
   */
  stopTaskMonitoring(executionId: number) {
    syncTaskMonitor.stopMonitoring(executionId);
  }

  /**
   * 获取当前监控的任务数量
   */
  getMonitoringTaskCount(): number {
    return syncTaskMonitor.getMonitoringTaskCount();
  }

  /**
   * 检查是否正在监控指定任务
   */
  isTaskMonitoring(executionId: number): boolean {
    return syncTaskMonitor.isMonitoring(executionId);
  }

  /**
   * 清理所有监控任务
   */
  clearAllMonitoring() {
    syncTaskMonitor.clearAllMonitoring();
  }

  /**
   * 检查管理器是否已初始化
   */
  isReady(): boolean {
    return this.isInitialized && this.syncProgressHook !== null;
  }
}

// 导出单例实例
export const globalSyncTaskManager = new GlobalSyncTaskManager();

// 导出便捷函数，供全局使用
export const {
  startSyncTask,
  updateSyncProgress,
  completeSyncTask,
  pauseSyncTask,
  resumeSyncTask,
  cancelSyncTask,
  failSyncTask,
  startTaskMonitoring,
  stopTaskMonitoring,
  getMonitoringTaskCount,
  isTaskMonitoring,
  clearAllMonitoring
} = globalSyncTaskManager;
